package com.koocloud.electroplatemanage.auth.service.impl;


import com.koocloud.electroplatemanage.auth.mapper.IRoleDao;
import com.koocloud.electroplatemanage.auth.mapper.IUserDao;
import com.koocloud.electroplatemanage.auth.service.IUserService;
import com.koocloud.electroplatemanage.common.util.CommonUtils;
import com.koocloud.electroplatemanage.pojo.Permission;
import com.koocloud.electroplatemanage.pojo.Role;
import com.koocloud.electroplatemanage.pojo.User;
import com.koocloud.electroplatemanage.utils.ListUtil;
import com.koocloud.electroplatemanage.utils.SecondCheck;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

@Service
public class IUserServiceimpl implements IUserService {
	@Resource
	com.koocloud.electroplatemanage.auth.mapper.IUserDao IUserDao;
	@Resource
	com.koocloud.electroplatemanage.auth.mapper.IRoleDao IRoleDao;
	/**
	 * 添加用户
	 */
	@Override
	public Integer  addUser(String userName,String password,String fullName,String jobNum,String regPhone,String superiorId,String departmentId) {
		//新添加的用户初始密码暂定为6个8
		if(!Pattern.matches("^[a-zA-Z0-9].{5,9}$",password)){return 0;}
		password = CommonUtils.md5(password);
		if(IUserDao.getJobNumWhenAdd(jobNum) != 0){return 0;}
		if(!SecondCheck.jobNumCheck(jobNum)){return 0;}
		Integer num = IUserDao.addUser(password,userName,fullName,jobNum,regPhone,superiorId,departmentId);
		return num;
	}
	/**
	 * 修改用户
	 */
	@Override
	public Integer updateUser(String id, String userName,String password,String jobNum,String fullName,String regPhone,String superiorId,String departmentId) {
		//根据用户id进行修改用户信息
		if(IUserDao.getJobNumWhenEdit(id,jobNum) != 0){return 0;}
		if(!Pattern.matches("^[A-Za-z0-9]+$",jobNum)){return 0;}
		if(password == null || password == "" || password .equals("")){
			Integer num=IUserDao.updateUserWithOutPassword(id,userName,jobNum,fullName,regPhone,superiorId,departmentId);
			return num;}
		else {
			if(!Pattern.matches("^[a-zA-Z0-9].{5,9}$",password)){return 0;}
			password = CommonUtils.md5(password);
			Integer num=IUserDao.updateUser(id,userName,password,jobNum,fullName,regPhone,superiorId,departmentId);
			return num;
		}
	}
	/**
	 * 根据多条件查询用户
	 */
	@Override
	public List<User> selectUser(String idOrName) {
		//根据多查询条件查询用户
	   List<User>  list = IUserDao.selectUser(idOrName);
	   for (User user : list) {
	      String  roleListStr = IRoleDao.selectAllRoleByUserId(user.getId());
	      user.setRoleListStr(roleListStr);//存放每个用户所拥有的角色列表  用逗号进行分开
    }
		return list;
	}
	
	
	
	
	/**
	 *用户删除
	 */
	@Override
	public Integer deleteUser(String id,int enableFlag) {
		//根据用户id删除用户
	   Integer  num = IUserDao.deleteUser(id,enableFlag);
		return num;
	}
	/**
	 * 根据用户id查询已有的角色列表以及未有的角色列表  （弃用）
	 */
	@Override
	public Map<String, Object> selectRoleList(String id) {
		Map<String, Object> map = new HashMap<>();
		//根据用户id查询已有的角色列表
	    List<String>  list = IUserDao.selectRoleList(id);
	    if (!list.isEmpty() &&  !StringUtils.isEmpty(list.get(0))) {
	    	 map.put("hasRoleList", list);
		}else {
			map.put("hasRoleList","");
		}
	    //查询所有的角色列表
	    List<String> list2=IUserDao.selectAllRoleList();
	    //存放该用户未有的角色列表
	    ArrayList<String> list3 = new ArrayList<>();
	    for (int i = 0; i < list2.size(); i++) {
	    	System.out.println(list2.get(i));
	    	if (!list.contains(list2.get(i))) {
				list3.add(list2.get(i));
			}
		}
	    System.out.println("该用户未有的角色列表为:"+list3);
	   
	    map.put("NoRoleList", list3);
		map.put("code", 1);
		return map;
	}
	/**
	 * 根据用户id分配角色列表
	 */
	@Override
	public Boolean insertRoleList(String id, String hasRoleList2) {
		try {
			String hasRoleList = hasRoleList2.replace(" ", "");
			//根据hasRoleList获取对应的role_id
			ArrayList<String> list = new ArrayList<>();
			System.out.println("list之前是否为空:"+list.isEmpty());
			System.out.println("list之前的size大小:"+list.size());
			String[] split=null;
			if (hasRoleList.contains(",")) {
				split = hasRoleList.split(",");	
				for (String roleName : split) {
					String roleId=IRoleDao.selectRoleId(roleName);
					if (!StringUtils.isEmpty(roleId)) {
						list.add(roleId);
					}
				}
			}else {
				//根据角色名查询角色id
				String  roleId=  IRoleDao.selectRoleId(hasRoleList);
				if (!StringUtils.isEmpty(roleId)) {
					list.add(roleId);
				}
				
			}
			System.out.println("最后的list,角色id集合为:"+list);
			//根据用户id删除之前的用户角色关系
			Integer num =IUserDao.deleteUserRoleRelation(id);
			//根据用户id重新建立用户角色之间的关系
			System.out.println("list之后是否为空:"+list.isEmpty());
			System.out.println("list之后的size大小:"+list.size());
			if (!list.isEmpty()) {
				for (String roleid : list) {
					Integer num2 =IUserDao.insert(id,roleid);
				}
			}
			return true;
		} catch (Exception e) {
			System.out.println(e.toString());
			return false;
		}	
	}
	/**
	 * 根据角色id获取已有的权限列表和未有的权限列表（弃用）
	 */
	@Override
	public Map<String, Object> selectAuthList(String id) {
		Map<String, Object> map = new HashMap<>();
		//根据角色id查询已有的权限列表
	    List<String>  list = IRoleDao.selectAuthList(id);
	    if (!list.isEmpty() &&  !StringUtils.isEmpty(list.get(0))) {
	    	 map.put("hasRoleList", list);
		}else {
			map.put("hasRoleList","");
		}
	    //查询所有的权限列表
	    List<String> list2=IUserDao.selectAllAuthList();
	    //存放该用户未有的角色列表
	    ArrayList<String> list3 = new ArrayList<>();
	    for (int i = 0; i < list2.size(); i++) {
	    	System.out.println(list2.get(i));
	    	if (!list.contains(list2.get(i))) {
				list3.add(list2.get(i));
			}
		}
	    System.out.println("该用户未有的权限列表为:"+list3);
	    map.put("NoRoleList", list3);
		return map;
	}
	/**
	 * 测试专用  插入整个对象
	 */
	@Override
	public Integer insertUser(User user) {
		Integer integer= IUserDao.insertUser(user);
		return integer;
	}
	/**
	 * 根据token返回用户信息
	 */
	@Override
	public User selectUserByToken(String username) {
		User user =null;
//		Jedis jedis = new Jedis("115.28.129.171", 6379);
//		jedis.auth("123456");
//		String username = jedis.get("token");
		if (StringUtils.isEmpty(username)) {
//			username="admin";//TODO 后面要修改
			 user= IUserDao.selectUserByToken(username);
			//	return new User();
		}else {
			 user = IUserDao.selectUserByToken(username);
		}
		return user;
	}
	/**
	 * 根据id查询用户
	 */
	@Override
	public User selectUserById(int id) {
		User user =IUserDao.selectUserById(id);
        String  roleListStr = IRoleDao.selectAllRoleByUserId(user.getId());
        user.setRoleListStr(roleListStr);//存放每个用户所拥有的角色列表  用逗号进行分开
		return user;
	}
	/**
	 * 根据id修改密码
	 */
	@Override
	public Integer updateUserPassword(int id, String md5) {
		Integer numInteger = IUserDao.updateUserPassword(id,md5);
		return numInteger;
	}
	/**
	 * 根据id重置密码
	 */
	@Override
	public Integer resetPassword(int id, String md5) {
		Integer numInteger = IUserDao.updateUserPassword(id,md5);
		return numInteger;
	}
	/**
	 * 根据用户名获取列表
	 */
	@Override
	public List<Map<String, Object>> selectUserByName(String userName) {
		List<Map<String, Object>> list=IUserDao.selectUserByName(userName);
		return list;
	}
	/**
	 * 根据id获取权限列表
	 */
	@Override
	public Map<String, Object> selectAuthListById(String id) {
		 Map<String,Object> data = new HashMap<String,Object>();
		    try {//根据角色id查询所有菜单
		    	 List<Permission> allMenu =null;
		      if (!StringUtils.isEmpty(id)) {
		    	allMenu = IRoleDao.findTree(id);
			}
		      //根节点
		      List<Permission> rootMenu = new ArrayList<Permission>();
		      for (Permission nav : allMenu) {
		        if(nav.getParentId() == -1){//父节点是-1的话,为根节点。
		          rootMenu.add(nav);
		        }
		      }
		      /* 根据Menu类的order排序 */
		      Collections.sort(rootMenu, Permission.order());
		      //为根菜单设置子菜单，getClild是递归调用的
		      for (Permission nav : rootMenu) {
		        /* 获取根节点下的所有子节点 使用getChild方法*/
		        List<Permission> childList = getChild(nav.getId(), allMenu);
		        nav.setChildren(childList);//给根节点设置子节点
		      }
		      /**
		                 * 输出构建好的菜单数据。
		       *
		       */
		      data.put("code", 0);
		      data.put("list", rootMenu);
		      return data;
		    } catch (Exception e) {
		      data.put("code", 1);
		      data.put("list", new ArrayList());
		      data.put("message", "无权限");
		      return data;
		    }
	}
	
	
	/**
	   * 获取子节点
	   * @param id 父节点id
	   * @param allMenu 所有菜单列表
	   * @return 每个根节点下，所有子菜单列表
	   */
	  public List<Permission> getChild(long id,List<Permission> allMenu){
	    //子菜单
	    List<Permission> childList = new ArrayList<Permission>();
	    for (Permission nav : allMenu) {
	      // 遍历所有节点，将所有菜单的父id与传过来的根节点的id比较
	      //相等说明：为该根节点的子节点。
	      if(nav.getParentId() == id){
	        childList.add(nav);
	      }
	    }
	    //递归
	    for (Permission nav : childList) {
	      nav.setChildren(getChild(nav.getId(), allMenu));
	    }
	    Collections.sort(childList,Permission.order());//排序
	    //如果节点下没有子节点，返回一个空List（递归退出）
	    if(childList.size() == 0){
	      return new ArrayList<Permission>();
	    }
	    return childList;
	  }
	  
	  /**
	   * 根据用户id获取对应的角色列表
	   */
	@Override
	public List<Role> selectRoleListByUserId(int id) {
		List<Role> list=  IUserDao.selectRoleListByUserId(id);
		return list;
	}
	
	/**
	 * 根据角色id获取权限
	 */
	@Override
	public List<Permission> selectAuthListById2(String id) {
		List<Permission> list=IUserDao.selectAuthListById2(id);
		return list;
	}


	/**
	 * 添加员工
	 */
	@Override
	public Integer addUserInfo(String id, String userName, String md5) {
		Integer num =IUserDao.addUserInfo(id,userName,md5);
		return num;
	}
	/**
	 * 获取所有的用户
	 */
    @Override
    public List<User> selectOrganizationStruct() {
        // TODO Auto-generated method stub
        //存根节点的
        List<User> rootUser=new ArrayList<>();
        
        List<User> allUser = IUserDao.selectOrganizationStruct();
        if (ListUtil.isEmpty(allUser)) {//为空
            new ArrayList<User>();
        }else {//不为空
            for (User user : allUser) { //遍历所有的
                if (user.getSuperiorId() == -1) {//父节点是-1的话，为根节点
                    rootUser.add(user);
                }
            }
            /* 根据User类的superiorId所属上级id排序 */
            Collections.sort(rootUser, User.order());
            //为根节点设置子节点，getChild是递归调用的
            for (User user : rootUser) {
                //获取根节点下的所有子节点， 使用getChild方法
                List<User> childList=getSon(user.getId(),allUser);
                user.setChildren(childList);
            }
            
        }
        
        return rootUser;
    }
    private List<User> getSon(long id, List<User> allUser) {
        //子节点
        List<User> childList = new ArrayList<>();
        for (User user : allUser) {
         // 遍历所有节点，将所有（用户的上级领导 父id）与传过来的根节点的id比较
            // 相等说明：为该根节点的子节点。
            if (user.getSuperiorId() == id) {
                childList.add(user);
            }
            
        }
        //递归
        for (User user : childList) {
            user.setChildren(getSon(user.getId(), allUser));
        }
        /* 根据User类的superiorId所属上级id排序 */
        Collections.sort(childList, User.order());
        // 如果节点下没有子节点，返回一个空List（递归退出）
        if (childList.size()==0) {
            return new ArrayList<User>();
        }
        return childList;
    }
    
    
    /***
     * 维护组织架构
     */
    @Override
    public List<User> maintainOrganizationStruct(String userName) {
        List<User>  userList;
        if (org.springframework.util.StringUtils.isEmpty(userName)) {//为空查询所有用户
             userList =IUserDao.selectAllUser();  
        }else {//不为空  查询除了该用户以外的所有用户
            userList= IUserDao.selectAllUserExclude(userName);
        }
        return userList;
    }
    /**
     * 获取所有的id除了当然登录人自己的
     */
    @Override
    public List<User> getSuperiorLeaderIds(long id) {
        List<User> userList= IUserDao.getSuperiorLeaderIds(id);
        return userList;
    }
	@Override
	public List<User> getUserOrderByDepartment(){
		return IUserDao.getUserOrderByDepartment();
	}
}
